import java.io.*;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
    /**
     * 并查集的实现（虽然现在不知道并查集的应用场景，但是听过原理后，已经可以写出代码了）*/

    // 定义数组最大值（题目要求）
    public static int MAX_VALUE = 100_0001;

    // 定义指向数组（保存对应元素所指向的元素）
    public static int[] father = new int[MAX_VALUE];

    // 定义内存数组（保存以该元素为代表元素时，集合容量）
    public static int[] size = new int[MAX_VALUE];

    // 定义栈数组（保存遍历过的元素，用于扁平化优化）
    public static int[] stack = new int[MAX_VALUE];

    public static void main(String[] args) throws IOException {
        // 使用BufferedReader和PrintWriter提高IO效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());

        // 初始化
        initialize();

        // 接收输入
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int opt = Integer.parseInt(st.nextToken());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());

            // 检查输入合法性
            if (a >= MAX_VALUE || b >= MAX_VALUE) {
                if (opt == 1) out.println("No");
                continue;
            }

            if (opt == 1) {
                if (isSameSet(a, b)) {
                    out.println("Yes");
                } else {
                    out.println("No");
                }
            } else {
                union(a, b);
            }
        }

        out.flush();
        out.close();
    }

    public static void initialize() {
        /**
         * 初始化
         *  初始时均指向自己，且集合大小为1*/
        for(int i = 0; i < MAX_VALUE; i++) {
            father[i] = i;
            size[i] = 1;
        }
    }

    public static boolean isSameSet(int a, int b) {
        /**
         * 查询a和b这两个数是否属于一个集合
         * 只需查询代表元素是否一致*/
        return find(a) == find(b);
    }

    public static void union(int a, int b) {
        /**
         * 合并a和b所在的集合*/
        // 1 查询两个元素的代表元素
        int fa = find(a);
        int fb = find(b);

        // 2 不在一个集合时再联合
        if(fa != fb) {
            // -小挂大
            if(size[fa] >= size[fb]) {
                size[fa] += size[fb];
                father[fb] = fa;
            } else {
                size[fb] += size[fa];
                father[fa] = fb;
            }
        }
    }

    public static int find(int a) {
        /**
         * 查找a所在集合的代表元素，并作扁平化优化*/
        // 1 查看代表元素（遇见环）
        int i = 0;
        // -未遇见环
        while(a != father[a]) {
            stack[i++] = a;
            a = father[a];
        }

        // 2 扁平化（将沿途所有节点直接指向代表节点）
        while(i > 0) {
            father[stack[--i]] = a;
        }

        // 3 返回代表元素
        return a;
    }
}